#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>
#include <dirent.h>
#include <sys/stat.h>
#include <errno.h>

//对当前目录中所有文件执行ls -l命令 ./xarg ls -l
//递归遍历/home/user并对每个文件执行文件类型检查 ./xarg -r file /home/user
//# 查找并打印所有.txt文件的内容  ./xarg -r cat /path/to/search

// 使用参数执行命令
void run_command(char* program, char** args) {
    pid_t pid = fork();
    if (pid == 0) {
        // 子进程
        execvp(program, args);
        // 如果execvp返回，说明发生了错误
        perror("execvp");
        exit(1);
    } else if (pid < 0) {
        // fork失败
        perror("fork");
    }
    // 父进程继续执行
}

// 处理目录并对每个条目执行命令
void process_directory(const char* dir_path, char* command, char** base_args, int base_arg_count) {
    DIR* dir;
    struct dirent* entry;
    
    // 打开目录
    if ((dir = opendir(dir_path)) == NULL) {
        perror("opendir");
        return;
    }
    
    // 准备命令参数数组
    char* args[128];
    int i;
    
    // 复制基础参数
    for (i = 0; i < base_arg_count; i++) {
        args[i] = base_args[i];
    }
    
    // 读取目录条目
    while ((entry = readdir(dir)) != NULL) {
        // 跳过"."和".."
        if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
            continue;
        }
        
        // 构造条目的完整路径
        char full_path[1024];
        snprintf(full_path, sizeof(full_path), "%s/%s", dir_path, entry->d_name);
        
        // 将文件路径添加为最后一个参数
        args[base_arg_count] = full_path;
        args[base_arg_count + 1] = NULL;
        
        // 使用文件作为参数执行命令
        run_command(command, args);
    }
    
    // 关闭目录
    closedir(dir);
}

// 递归目录遍历
void traverse_directory(const char* dir_path, char* command, char** base_args, int base_arg_count, int recursive) {
    DIR* dir;
    struct dirent* entry;
    
    if ((dir = opendir(dir_path)) == NULL) {
        perror("opendir");
        return;
    }
    
    // 处理当前目录中的文件
    process_directory(dir_path, command, base_args, base_arg_count);
    
    // 如果设置了递归标志，处理子目录
    if (recursive) {
        if ((dir = opendir(dir_path)) == NULL) {
            perror("opendir");
            return;
        }
        
        while ((entry = readdir(dir)) != NULL) {
            if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
                continue;
            }
            
            char full_path[1024];
            snprintf(full_path, sizeof(full_path), "%s/%s", dir_path, entry->d_name);
            
            // 检查是否为目录
            struct stat path_stat;
            stat(full_path, &path_stat);
            
            if (S_ISDIR(path_stat.st_mode)) {
                traverse_directory(full_path, command, base_args, base_arg_count, recursive);
            }
        }
        
        closedir(dir);
    }
}

int main(int argc, char *argv[]) {
    int recursive = 0;
    int start_idx = 1;
    char* target_dir = ".";  // 默认为当前目录
    
    // 解析命令行参数
    if (argc < 2) {
        fprintf(stderr, "用法: %s [-r] 命令 [参数...] [目录]\n", argv[0]);
        exit(1);
    }
    
    // 检查递归标志
    if (strcmp(argv[1], "-r") == 0) {
        recursive = 1;
        start_idx++;
    }
    
    if (argc <= start_idx) {
        fprintf(stderr, "需要提供命令\n");
        exit(1);
    }
    
    char* command = argv[start_idx];
    
    // 准备基础参数（命令和任何固定参数）
    char** base_args = &argv[start_idx];
    int base_arg_count = argc - start_idx - 1; // -1 用于可能的目录参数
    
    // 检查最后一个参数是否为目录
    if (argc > start_idx + 1) {
        struct stat st;
        if (stat(argv[argc - 1], &st) == 0 && S_ISDIR(st.st_mode)) {
            target_dir = argv[argc - 1];
            base_arg_count--;  // 不要在命令参数中包含目录
        }
    }
    
    // 遍历目录并对每个文件执行命令
    traverse_directory(target_dir, command, base_args, base_arg_count, recursive);
    
    // 等待所有子进程
    int status;
    while (wait(&status) > 0);
    
    return 0;
}